from . import Sunny as SyNet
from .SunnyConst import *
from .SunnyDLL import SunnyRequest, SunnyResponse

def BytesToStr(b):
    try:
        return b.decode('utf-8')
    except:
        return b.decode('gbk')

class tcp_event_base():
    def __init__(self):
        pass

    def connect(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
                Data: bytearray, QueryId: int, Pid: int):
        '''
        连接成功
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 附加数据
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        print(f"客户进入：Referer:{Referer},RemoteUrl:{RemoteUrl}")
        pass

    def send(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
             Data: bytearray, QueryId: int, Pid: int):
        '''
        发送数据
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 附加数据
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        # print(f"发送数据：MessageId:{MessageId},QueryId:{QueryId},Pid:{Pid},Referer:{Referer},RemoteUrl:{RemoteUrl},长度:{len(Data)}")
        pass

    def receive(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
                Data: bytearray, QueryId: int, Pid: int):
        '''
        数据到达
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 附加数据
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        # print(f"数据到达：MessageId:{MessageId},QueryId:{QueryId},Pid:{Pid},Referer:{Referer},RemoteUrl:{RemoteUrl},长度:{len(Data)}")
        pass

    def close(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
              Data: bytearray, QueryId: int, Pid: int):
        '''
        断牙链接
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 附加数据
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        print(f"客户断开：Referer:{Referer},RemoteUrl:{RemoteUrl}")
        pass

    def before_connect(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
                       Data: bytearray, QueryId: int, Pid: int):
        '''
        即将链接
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 附加数据
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        # print(f"即将链接：MessageId:{MessageId},QueryId:{QueryId},Pid:{Pid},Referer:{Referer},RemoteUrl:{RemoteUrl}")
        pass


class udp_event_base():
    def __init__(self):
        pass

    def close(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int, QueryId: int, Pid: int):
        '''
        断开链接
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        print("UDP 断开链接", MessageId, QueryId, Pid, Referer, RemoteUrl)
        pass

    def send(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
             Data: bytearray, QueryId: int, Pid: int):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 发送的 Body
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        print("UDP 发送数据", MessageId, QueryId, Pid, Referer, RemoteUrl, Data)
        pass

    def receive(self, SunnyContext: int, Referer: str, RemoteUrl: str, MessageId: int,
                Data: bytearray, QueryId: int, Pid: int):
        '''
        数据到达
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param Data: 发送的 Body
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        print("UDP 数据到达", MessageId, QueryId, Pid, Referer, RemoteUrl, Data)
        pass


class wss_event_base():
    def __init__(self):
        pass

    def connect(self, SunnyContext: int, QueryId: int, MessageId: int, QueryMethod: str,
                Url: str, Pid: int, WssMessageType: int, Data: bytes):
        '''
        连接成功
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param QueryId: 同一个请求 的发送和响应 唯一ID一致
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致
        :param QueryMethod: 请求方法 例如POST GET PUT
        :param Url: 请求的URL
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :param WssMessageType: ws/wss 发送或接收的消息类型 参考 WSS_MESSAGE_CONST
        :param Data: 附加数据
        :return:
        '''
        print("WSS 连接成功", Url, QueryMethod, Pid, WssMessageType, Data)
        pass

    def send(self, SunnyContext: int, QueryId: int, MessageId: int, QueryMethod: str,
             Url: str, Pid: int, WssMessageType: int, Data: bytes):
        '''
        发送数据
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param QueryId: 同一个请求 的发送和响应 唯一ID一致
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致
        :param QueryMethod: 请求方法 例如POST GET PUT
        :param Url: 请求的URL
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :param WssMessageType: ws/wss 发送或接收的消息类型 参考 WSS_MESSAGE_CONST
        :param Data: 附加数据
        :return:
        '''
        print("WSS 发送数据", Url, QueryMethod, Pid, WssMessageType, Data)
        pass

    def receive(self, SunnyContext: int, QueryId: int, MessageId: int, QueryMethod: str,
                Url: str, Pid: int, WssMessageType: int, Data: bytes):
        '''
        数据到达
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param QueryId: 同一个请求 的发送和响应 唯一ID一致
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致
        :param QueryMethod: 请求方法 例如POST GET PUT
        :param Url: 请求的URL
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :param WssMessageType: ws/wss 发送或接收的消息类型 参考 WSS_MESSAGE_CONST
        :param Data: 附加数据
        :return:
        '''
        print("WSS 数据到达", Url, QueryMethod, Pid, WssMessageType, Data)
        pass

    def close(self, SunnyContext: int, QueryId: int, MessageId: int, QueryMethod: str,
              Url: str, Pid: int):
        '''
        断开连接
        :return:
        '''
        print("WSS 连开链接", Url, QueryMethod, Pid)
        pass


class http_event_base():
    def __init__(self):
        pass

    def request(self, SunnyContext: int, MessageId: int, Pid: int, RequestId: int, Url: str, Method: str,
                RefererIp: str, SunnyRequest: SunnyRequest):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致 用 SyNet.MessageIdToSunny(MessageId) 取得 SyHTTP 对象
        :param Pid: 来源进程ID
        :param RequestId: 请求ID和响应ID 匹配
        :param Url: 请求地址
        :param Method: 请求方法
        :param RefererIp: 来源IP地址
        :param SunnyRequest: 请求对象实例
        :return:
        '''
        print("请求：" + Url)
        pass

    def response(self, SunnyContext: int, MessageId: int, Pid: int, RequestId: int, Url: str, Method: str,
                 RefererIp: str, SunnyResponse: SunnyResponse):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致 用 SyNet.MessageIdToSunny(MessageId) 取得 SyHTTP 对象
        :param Pid: 来源进程ID
        :param RequestId: 请求ID和响应ID 匹配
        :param Url: 请求地址
        :param Method: 请求方法
        :param RefererIp: 来源IP地址
        :param SunnyResponse: 响应对象实例
        :return:
        '''
        print("响应：" + Url)
        pass

    def error(self, SunnyContext: int, MessageId: int, Pid: int, RequestId: int, Url: str, Method: str,
              RefererIp: str, Error: str):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致 用 SyNet.MessageIdToSunny(MessageId) 取得 SyHTTP 对象
        :param Pid: 来源进程ID
        :param RequestId: 请求ID和响应ID 匹配
        :param Url: 请求地址
        :param Method: 请求方法
        :param RefererIp: 来源IP地址
        :param Error: 错误文本
        :return:
        '''
        print("错误：", Url, MessageId, Pid, RequestId, Method, RefererIp, "Error", Error)
        pass


class SunnyClass():
    def __init__(self, port: int = 8888, http_event: http_event_base = None, wss_event: wss_event_base = None,
                 tcp_event: tcp_event_base = None, udp_event: udp_event_base = None):
        '''
        :param http_event: http事件
        :param wss_event: wss事件
        :param tcp_event: tcp事件
        :param udp_event: udp事件
        '''
        if http_event:
            self.http_event = http_event
        else:
            self.http_event = http_event_base()

        if wss_event:
            self.wss_event = wss_event
        else:
            self.wss_event = wss_event_base()

        if tcp_event:
            self.tcp_event = tcp_event
        else:
            self.tcp_event = tcp_event_base()

        if udp_event:
            self.udp_event = udp_event
        else:
            self.udp_event = udp_event_base()
        pass

        self.Sunny = SyNet.SunnyNet()
        self.port = port
        self.Sunny.setPort(self.port)
        self.Sunny.Install_certificate()
        self.isIEProxy = False
        self.Sunny.bind_event(http_event=self.__Http, tcp_event=self.__Tcp, wss_event=self.__Wss, udp_event=self.__UDP)

    def addProess(self, name: str = None, pid: int = None):
        self.Sunny.process_proxy_add_process(name=name, pid=pid)

    def stop(self):
        if self.isIEProxy:
            self.Sunny.close_ie_proxy()
        self.Sunny.stop_sunny()

    def start(self, isLoadDriver: bool = True, isSetIEProxy: bool = False, onlyTCP: bool = False):
        '''
        启动 Sunny
        :param isLoadDriver: 是否加载进程驱动
        :param isSetIEProxy: 是否设置全局IE代理
        :param onlyTCP: 是否仅便用TCP转发
        :return:
        '''
        self.isIEProxy = isSetIEProxy
        if onlyTCP:
            self.Sunny.set_force_client_use_tcp(open=True)
        else:
            self.Sunny.set_force_client_use_tcp(open=False)
        if not self.Sunny.start_sunny():
            print("启动失败")
            print(self.Sunny.getError())
            return False
        else:
            print("正在运行 0.0.0.0:" + str(self.port))
            if isLoadDriver:
                if not self.Sunny.process_proxy_load_driver():
                    print("加载驱动失败，进程代理不可用(注意，需要管理员权限（请检查），win7请安装 KB3033929 补丁)")
                    return False
                else:
                    # Sunny.进程代理_添加进程名("WeChat.exe")
                    if self.isIEProxy:
                        self.Sunny.set_ie_proxy()
                    print("启动成功")
                    return True
            else:
                if self.isIEProxy:
                    self.Sunny.set_ie_proxy()
                print("启动成功")
                return True

    def __Http(self, SunnyContext: int, RequestId: int, MessageId: int, MessageType: int, Method: bytearray,
               Url: bytearray, ErrorInfo: bytearray, Pid: int):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param RequestId: 同一个请求 的发送和响应 唯一ID一致
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致
        :param MessageType: 参考 HTTP_CONST
        :param Method: 请求方式 例如POST GET PUT
        :param Url: 请求的URL
        :param ErrorInfo: 如果消息类型 =  请求失败 错误信息=请求错误的原因
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        Method = BytesToStr(Method)
        Url = BytesToStr(Url)
        SyHTTP = SyNet.MessageIdToSunny(MessageId)
        RefererIp = SyHTTP.GetRefererIp()
        if MessageType == HTTP_CONST.SEND:
            Request = SyHTTP.GetRequest()
            # 避免返回数据是压缩的，有时候尽管你这里删除了压缩标记，返回数据依旧是压缩的,就需要你自己根据返回协议头中的压缩方式，自己手动解压数据
            Request.DeleteZipTag()
            self.http_event.request(SunnyContext=SunnyContext, MessageId=MessageId, Pid=Pid, RequestId=RequestId,
                                    Url=Url,
                                    Method=Method, RefererIp=RefererIp, SunnyRequest=Request)
        elif MessageType == HTTP_CONST.RESPONSE:
            # 先检查数据是不是压缩的，如果是压缩的先解压
            Response = SyHTTP.GetResponse()
            Encoding = Response.getHeaders(key="Content-Encoding")
            Encoding = Encoding.lower()
            if Encoding == "gzip" or Encoding == "br" or Encoding == "deflate":
                Response.deleteHeaders(key="Content-Encoding")
                data = Response.getResponse()
                if Encoding == "gzip":
                    data = SyNet.GzipDecode(data)
                    if len(data) > 0:
                        Response.modifyReponse(data=data)
                if Encoding == "br":
                    data = SyNet.BrDecode(data)
                    if len(data) > 0:
                        Response.modifyReponse(data=data)
                if Encoding == "deflate":
                    data = SyNet.DeflateDecode(data)
                if len(data) > 0:
                    Response.modifyReponse(data=data)
            self.http_event.response(SunnyContext=SunnyContext, MessageId=MessageId, Pid=Pid, RequestId=RequestId,
                                     Url=Url,
                                     Method=Method,
                                     RefererIp=RefererIp, SunnyResponse=Response)

        elif MessageType == HTTP_CONST.ERROR:
            ErrorInfo = BytesToStr(ErrorInfo)
            self.http_event.error(SunnyContext=SunnyContext, MessageId=MessageId, Pid=Pid, RequestId=RequestId, Url=Url,
                                  Method=Method,
                                  RefererIp=RefererIp, Error=ErrorInfo)

    def __Tcp(self, SunnyContext: int, Referer: bytearray, RemoteUrl: bytearray, MessageType: int, MessageId: int,
              DataPtr: int, DataLenght: int, QueryId: int, Pid: int):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageType: 参考 TCP_CONST
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param DataPtr: 发送或接收的数据指针
        :param DataLenght: 发送或接收的数据长度
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''

        _Referer = BytesToStr(Referer)
        _RemoteUrl = BytesToStr(RemoteUrl)
        _Data = SyNet.TCP.GetData(DataPtr=DataPtr, lenght=DataLenght)

        if MessageType == TCP_CONST.BEFORE_CONNECT:
            self.tcp_event.before_connect(SunnyContext=SunnyContext,
                                          Referer=_Referer,
                                          RemoteUrl=_RemoteUrl,
                                          MessageId=MessageId,
                                          Data=_Data,
                                          QueryId=QueryId,
                                          Pid=Pid)

        elif MessageType == TCP_CONST.CLOSE_CONNECT:
            self.tcp_event.close(SunnyContext=SunnyContext,
                                 Referer=_Referer,
                                 RemoteUrl=_RemoteUrl,
                                 MessageId=MessageId,
                                 Data=_Data,
                                 QueryId=QueryId,
                                 Pid=Pid)
        elif MessageType == TCP_CONST.CONNECT_SUCCESS:
            self.tcp_event.connect(SunnyContext=SunnyContext,
                                   Referer=_Referer,
                                   RemoteUrl=_RemoteUrl,
                                   MessageId=MessageId,
                                   Data=_Data,
                                   QueryId=QueryId,
                                   Pid=Pid)
        elif MessageType == TCP_CONST.RECEIVED:
            self.tcp_event.receive(SunnyContext=SunnyContext,
                                   Referer=_Referer,
                                   RemoteUrl=_RemoteUrl,
                                   MessageId=MessageId,
                                   Data=_Data,
                                   QueryId=QueryId,
                                   Pid=Pid)
        elif MessageType == TCP_CONST.SEND_DATA:
            self.tcp_event.send(SunnyContext=SunnyContext,
                                Referer=_Referer,
                                RemoteUrl=_RemoteUrl,
                                MessageId=MessageId,
                                Data=_Data,
                                QueryId=QueryId,
                                Pid=Pid)
        else:
            print("未知消息类型", MessageType)
        pass

    def __UDP(self, SunnyContext: int, Referer: bytearray, RemoteUrl: bytearray, MessageType: int, MessageId: int,
              QueryId: int, Pid: int):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param Referer: 由哪个地址发起的请求，例如 127.0.0.1:1234
        :param RemoteUrl: 远程地址，例如 8.8.8.8:1234 或 baidu.com:443
        :param MessageType: 参考 UDP_CONST
        :param MessageId: 同一个请求 的连接/发送/响应/断开/即将连接 MessageId不一致
        :param QueryId: 同一个请求 的连接/发送/响应/断开/即将连接 唯一ID一致
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :return:
        '''
        _Referer = BytesToStr(Referer)
        _RemoteUrl = BytesToStr(RemoteUrl)
        if MessageType == UDP_CONST.SEND:
            _Data = SyNet.UDP.GetData(MessageId)
            self.udp_event.send(SunnyContext=SunnyContext,
                                Referer=_Referer,
                                RemoteUrl=_RemoteUrl,
                                MessageId=MessageId,
                                Data=_Data,
                                QueryId=QueryId,
                                Pid=Pid)
        elif MessageType == UDP_CONST.RECEIVE:
            _Data = SyNet.UDP.GetData(MessageId)
            self.udp_event.receive(SunnyContext=SunnyContext,
                                   Referer=_Referer,
                                   RemoteUrl=_RemoteUrl,
                                   MessageId=MessageId,
                                   Data=_Data,
                                   QueryId=QueryId,
                                   Pid=Pid)
        elif MessageType == UDP_CONST.CLOSE:
            self.udp_event.close(SunnyContext=SunnyContext,
                                 Referer=_Referer,
                                 RemoteUrl=_RemoteUrl,
                                 MessageId=MessageId,
                                 QueryId=QueryId,
                                 Pid=Pid)
            pass
        else:
            print("未知消息类型", MessageType)

    def __Wss(self, SunnyContext: int, QueryId: int, MessageId: int, MessageType: int, QueryMethod: bytearray,
              Url: bytearray, Pid: int, WssMessageType: int):
        '''
        :param SunnyContext: Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :param QueryId: 同一个请求 的发送和响应 唯一ID一致
        :param MessageId: 同一个请求 的发送和响应 MessageId不一致
        :param MessageType: 参考 WSS_CONST
        :param QueryMethod: 请求方法 例如POST GET PUT
        :param Url: 请求的URL
        :param Pid: 进程PID 若等于0 表示通过代理请求 无进程PID
        :param WssMessageType: ws/wss 发送或接收的消息类型 参考 WSS_MESSAGE_CONST
        :return:
        '''
        _Url = BytesToStr(Url)
        _QueryMethod = BytesToStr(QueryMethod)
        if MessageType == WSS_CONST.SEND_DATA:
            _Data = SyNet.WSS.GetData(MessageId)
            self.wss_event.send(SunnyContext=SunnyContext,
                                Url=_Url,
                                QueryMethod=_QueryMethod,
                                MessageId=MessageId,
                                QueryId=QueryId,
                                Pid=Pid,
                                WssMessageType=WssMessageType,
                                Data=_Data)
            pass
        elif MessageType == WSS_CONST.RECEIVED:
            _Data = SyNet.WSS.GetData(MessageId)
            self.wss_event.receive(SunnyContext=SunnyContext,
                                   Url=_Url,
                                   QueryMethod=_QueryMethod,
                                   MessageId=MessageId,
                                   QueryId=QueryId,
                                   Pid=Pid,
                                   WssMessageType=WssMessageType,
                                   Data=_Data)
            pass
        elif MessageType == WSS_CONST.CONNECT_SUCCESS:
            _Data = SyNet.WSS.GetData(MessageId)
            self.wss_event.connect(SunnyContext=SunnyContext,
                                   Url=_Url,
                                   QueryMethod=_QueryMethod,
                                   MessageId=MessageId,
                                   QueryId=QueryId,
                                   Pid=Pid,
                                   WssMessageType=WssMessageType,
                                   Data=_Data)
            pass
        elif MessageType == WSS_CONST.CLOSE_CONNECT:
            self.wss_event.close(SunnyContext=SunnyContext,
                                 Url=_Url,
                                 QueryMethod=_QueryMethod,
                                 MessageId=MessageId,
                                 QueryId=QueryId,
                                 Pid=Pid)
            pass
        else:
            print("未知消息类型", MessageType)


if __name__ == '__main__':
    import time

    sn = SunnyClass()
    while True:
        time.sleep(1)
